<!doctype html><html class="not-ready lg:text-base" style=--bg:#faf8f1 lang=en-us><head><meta charset=utf-8><meta http-equiv=X-UA-Compatible content="IE=edge"><meta name=viewport content="width=device-width,initial-scale=1,shrink-to-fit=no"><title>Thinking in Rust No.2 Sized，?Sized - mindbox's blog</title>
<meta name=theme-color><meta name=description content="我想聊的内容基本全部基于Rust的基本库，应该说大部分聊的是core库。 本期聊的内容是Sized，这是一个平时基本用不到，但是最基础的概念。
Rust基本库 Rust的基本库分为三层，core，alloc和std。
core包含rust最核心的内容，该库除了编译器不依赖任何外部环境，包括堆内存。 alloc在core基础上添加堆内存的支持，从名字就可以看出来，该库还依赖compiler_builtins，一个公开的库，在crates.io上有，可以查看 impl<T> Box<T> { pub fn new(x: T) -> Self { #[rustc_box] Box::new(x) } } 所有的堆分配都会最终到这里，分配堆内存。
我们熟悉的Box，Vec都是在这个alloc库中。
std 标准库，依赖alloc，和许多其他的库，比如现在标准库HashMap就是依赖hashbrown库实现的，就是crates.io上那个。 具体来说是std依赖于alloc，alloc依赖于core，core只依赖编译器。 一般来说写应用是使用std，写嵌入式一般只依赖alloc，如果是写内核，那就只能依赖core了。
marker 在core库中有一个叫marker的mod，里面包含的内容主要有：
Sized，Copy，Send，Sync，Unpin五个Trait PhantomData，PhantomPinned两个Struct Derive Copy的宏。 为什么这些内容在这个mod中呢？这个mod中的内容与编译器的行为息息相关，我们看到的每一个Trait，它们的大小都是零，目的只是给所有的类型添加一个开关。 为什么叫marker，因为对于每一个类型，以上五个Trait编译的时候都能得到是或者否的答案。
这些内容我们大概可以分为四个部分
Sized Copy，Derive Copy Send，Sync，PhantomData Unpin，PhantomPinned 我会逐步的聊这几个部分，本期先聊Sized。
数据与内存 我们使用的所有变量，都是数据，数据要保存在内存中，在保存的时候都需要一个大小，就是占多大的内存，这个大小编译器会自动计算，对于能够计算出大小的类型，都会标注为Sized。 也就是是说编译器自动为所有能够计算大小的类型实现了该Trait。
struct A(u32); let a1:A; let a2:&amp;A; 上面的a1，a2是两种不同的类型，编译器在编译的时候能够计算到它们的长度，所以每一个都自动实现了Sized。 也就是说编译器自动为我们做了下面的事情。
impl Sized for A; impl Sized for &amp;A; 是的，A，&amp;A完完全全是两个东西，但是为啥我们在a1或者a2 上都可以通过 . 来调用它们的函数呢？这个涉及到Deref，刨坑待填。
所以Sized 是一个开关，编译器自动帮所有类型确定，那么既然是开关，开就是有固定长度，关就是没有固定长度，那么什么是没有固定长度呢？
DST（dynamically sized types） 在Rust中，在编译的时候不能确定长度的类型，有一个专有名词叫DST。"><meta name=author content="mindbox"><link rel="preload stylesheet" as=style href=https://mindbox.gitee.io/blog/main.min.css><link rel=preload as=image href=https://mindbox.gitee.io/blog/theme.svg><link rel=preload as=image href=https://mindbox.gitee.io/blog/rss.svg><script defer src=https://mindbox.gitee.io/blog/highlight.min.js onload=hljs.initHighlightingOnLoad()></script><link rel=icon href=https://mindbox.gitee.io/blog/favicon.ico><link rel=apple-touch-icon href=https://mindbox.gitee.io/blog/apple-touch-icon.png><meta name=generator content="Hugo 0.121.2"><meta itemprop=name content="Thinking in Rust No.2 Sized，?Sized"><meta itemprop=description content="我想聊的内容基本全部基于Rust的基本库，应该说大部分聊的是core库。 本期聊的内容是Sized，这是一个平时基本用不到，但是最基础的概念。
Rust基本库 Rust的基本库分为三层，core，alloc和std。
core包含rust最核心的内容，该库除了编译器不依赖任何外部环境，包括堆内存。 alloc在core基础上添加堆内存的支持，从名字就可以看出来，该库还依赖compiler_builtins，一个公开的库，在crates.io上有，可以查看 impl<T> Box<T> { pub fn new(x: T) -> Self { #[rustc_box] Box::new(x) } } 所有的堆分配都会最终到这里，分配堆内存。
我们熟悉的Box，Vec都是在这个alloc库中。
std 标准库，依赖alloc，和许多其他的库，比如现在标准库HashMap就是依赖hashbrown库实现的，就是crates.io上那个。 具体来说是std依赖于alloc，alloc依赖于core，core只依赖编译器。 一般来说写应用是使用std，写嵌入式一般只依赖alloc，如果是写内核，那就只能依赖core了。
marker 在core库中有一个叫marker的mod，里面包含的内容主要有：
Sized，Copy，Send，Sync，Unpin五个Trait PhantomData，PhantomPinned两个Struct Derive Copy的宏。 为什么这些内容在这个mod中呢？这个mod中的内容与编译器的行为息息相关，我们看到的每一个Trait，它们的大小都是零，目的只是给所有的类型添加一个开关。 为什么叫marker，因为对于每一个类型，以上五个Trait编译的时候都能得到是或者否的答案。
这些内容我们大概可以分为四个部分
Sized Copy，Derive Copy Send，Sync，PhantomData Unpin，PhantomPinned 我会逐步的聊这几个部分，本期先聊Sized。
数据与内存 我们使用的所有变量，都是数据，数据要保存在内存中，在保存的时候都需要一个大小，就是占多大的内存，这个大小编译器会自动计算，对于能够计算出大小的类型，都会标注为Sized。 也就是是说编译器自动为所有能够计算大小的类型实现了该Trait。
struct A(u32); let a1:A; let a2:&amp;A; 上面的a1，a2是两种不同的类型，编译器在编译的时候能够计算到它们的长度，所以每一个都自动实现了Sized。 也就是说编译器自动为我们做了下面的事情。
impl Sized for A; impl Sized for &amp;A; 是的，A，&amp;A完完全全是两个东西，但是为啥我们在a1或者a2 上都可以通过 . 来调用它们的函数呢？这个涉及到Deref，刨坑待填。
所以Sized 是一个开关，编译器自动帮所有类型确定，那么既然是开关，开就是有固定长度，关就是没有固定长度，那么什么是没有固定长度呢？
DST（dynamically sized types） 在Rust中，在编译的时候不能确定长度的类型，有一个专有名词叫DST。"><meta itemprop=datePublished content="2023-10-31T05:23:48+08:00"><meta itemprop=dateModified content="2023-10-31T05:23:48+08:00"><meta itemprop=wordCount content="234"><meta itemprop=keywords content><meta property="og:title" content="Thinking in Rust No.2 Sized，?Sized"><meta property="og:description" content="我想聊的内容基本全部基于Rust的基本库，应该说大部分聊的是core库。 本期聊的内容是Sized，这是一个平时基本用不到，但是最基础的概念。
Rust基本库 Rust的基本库分为三层，core，alloc和std。
core包含rust最核心的内容，该库除了编译器不依赖任何外部环境，包括堆内存。 alloc在core基础上添加堆内存的支持，从名字就可以看出来，该库还依赖compiler_builtins，一个公开的库，在crates.io上有，可以查看 impl<T> Box<T> { pub fn new(x: T) -> Self { #[rustc_box] Box::new(x) } } 所有的堆分配都会最终到这里，分配堆内存。
我们熟悉的Box，Vec都是在这个alloc库中。
std 标准库，依赖alloc，和许多其他的库，比如现在标准库HashMap就是依赖hashbrown库实现的，就是crates.io上那个。 具体来说是std依赖于alloc，alloc依赖于core，core只依赖编译器。 一般来说写应用是使用std，写嵌入式一般只依赖alloc，如果是写内核，那就只能依赖core了。
marker 在core库中有一个叫marker的mod，里面包含的内容主要有：
Sized，Copy，Send，Sync，Unpin五个Trait PhantomData，PhantomPinned两个Struct Derive Copy的宏。 为什么这些内容在这个mod中呢？这个mod中的内容与编译器的行为息息相关，我们看到的每一个Trait，它们的大小都是零，目的只是给所有的类型添加一个开关。 为什么叫marker，因为对于每一个类型，以上五个Trait编译的时候都能得到是或者否的答案。
这些内容我们大概可以分为四个部分
Sized Copy，Derive Copy Send，Sync，PhantomData Unpin，PhantomPinned 我会逐步的聊这几个部分，本期先聊Sized。
数据与内存 我们使用的所有变量，都是数据，数据要保存在内存中，在保存的时候都需要一个大小，就是占多大的内存，这个大小编译器会自动计算，对于能够计算出大小的类型，都会标注为Sized。 也就是是说编译器自动为所有能够计算大小的类型实现了该Trait。
struct A(u32); let a1:A; let a2:&amp;A; 上面的a1，a2是两种不同的类型，编译器在编译的时候能够计算到它们的长度，所以每一个都自动实现了Sized。 也就是说编译器自动为我们做了下面的事情。
impl Sized for A; impl Sized for &amp;A; 是的，A，&amp;A完完全全是两个东西，但是为啥我们在a1或者a2 上都可以通过 . 来调用它们的函数呢？这个涉及到Deref，刨坑待填。
所以Sized 是一个开关，编译器自动帮所有类型确定，那么既然是开关，开就是有固定长度，关就是没有固定长度，那么什么是没有固定长度呢？
DST（dynamically sized types） 在Rust中，在编译的时候不能确定长度的类型，有一个专有名词叫DST。"><meta property="og:type" content="article"><meta property="og:url" content="https://mindbox.gitee.io/blog/posts/thinking-in-rust-no.2/"><meta property="article:section" content="posts"><meta property="article:published_time" content="2023-10-31T05:23:48+08:00"><meta property="article:modified_time" content="2023-10-31T05:23:48+08:00"><meta name=twitter:card content="summary"><meta name=twitter:title content="Thinking in Rust No.2 Sized，?Sized"><meta name=twitter:description content="我想聊的内容基本全部基于Rust的基本库，应该说大部分聊的是core库。 本期聊的内容是Sized，这是一个平时基本用不到，但是最基础的概念。
Rust基本库 Rust的基本库分为三层，core，alloc和std。
core包含rust最核心的内容，该库除了编译器不依赖任何外部环境，包括堆内存。 alloc在core基础上添加堆内存的支持，从名字就可以看出来，该库还依赖compiler_builtins，一个公开的库，在crates.io上有，可以查看 impl<T> Box<T> { pub fn new(x: T) -> Self { #[rustc_box] Box::new(x) } } 所有的堆分配都会最终到这里，分配堆内存。
我们熟悉的Box，Vec都是在这个alloc库中。
std 标准库，依赖alloc，和许多其他的库，比如现在标准库HashMap就是依赖hashbrown库实现的，就是crates.io上那个。 具体来说是std依赖于alloc，alloc依赖于core，core只依赖编译器。 一般来说写应用是使用std，写嵌入式一般只依赖alloc，如果是写内核，那就只能依赖core了。
marker 在core库中有一个叫marker的mod，里面包含的内容主要有：
Sized，Copy，Send，Sync，Unpin五个Trait PhantomData，PhantomPinned两个Struct Derive Copy的宏。 为什么这些内容在这个mod中呢？这个mod中的内容与编译器的行为息息相关，我们看到的每一个Trait，它们的大小都是零，目的只是给所有的类型添加一个开关。 为什么叫marker，因为对于每一个类型，以上五个Trait编译的时候都能得到是或者否的答案。
这些内容我们大概可以分为四个部分
Sized Copy，Derive Copy Send，Sync，PhantomData Unpin，PhantomPinned 我会逐步的聊这几个部分，本期先聊Sized。
数据与内存 我们使用的所有变量，都是数据，数据要保存在内存中，在保存的时候都需要一个大小，就是占多大的内存，这个大小编译器会自动计算，对于能够计算出大小的类型，都会标注为Sized。 也就是是说编译器自动为所有能够计算大小的类型实现了该Trait。
struct A(u32); let a1:A; let a2:&amp;A; 上面的a1，a2是两种不同的类型，编译器在编译的时候能够计算到它们的长度，所以每一个都自动实现了Sized。 也就是说编译器自动为我们做了下面的事情。
impl Sized for A; impl Sized for &amp;A; 是的，A，&amp;A完完全全是两个东西，但是为啥我们在a1或者a2 上都可以通过 . 来调用它们的函数呢？这个涉及到Deref，刨坑待填。
所以Sized 是一个开关，编译器自动帮所有类型确定，那么既然是开关，开就是有固定长度，关就是没有固定长度，那么什么是没有固定长度呢？
DST（dynamically sized types） 在Rust中，在编译的时候不能确定长度的类型，有一个专有名词叫DST。"><link rel=canonical href=https://mindbox.gitee.io/blog/posts/thinking-in-rust-no.2/></head><body class="text-black duration-200 ease-out dark:text-white"><header class="mx-auto flex h-[4.5rem] max-w-3xl px-8 lg:justify-center"><div class="relative z-50 mr-auto flex items-center"><a class="-translate-x-[1px] -translate-y-[1px] text-2xl font-semibold" href=https://mindbox.gitee.io/blog>mindbox's blog</a><div class="btn-dark text-[0] ml-4 h-6 w-6 shrink-0 cursor-pointer [background:url(./theme.svg)_left_center/cover_no-repeat] dark:invert dark:[background-position:right]" role=button aria-label=Dark></div></div><div class="btn-menu relative z-50 -mr-8 flex h-[4.5rem] w-[5rem] shrink-0 cursor-pointer flex-col items-center justify-center gap-2.5 lg:hidden" role=button aria-label=Menu></div><script>const htmlClass=document.documentElement.classList;setTimeout(()=>{htmlClass.remove("not-ready")},10);const btnMenu=document.querySelector(".btn-menu");btnMenu.addEventListener("click",()=>{htmlClass.toggle("open")});const metaTheme=document.querySelector('meta[name="theme-color"]'),lightBg="#faf8f1".replace(/"/g,""),setDark=e=>{metaTheme.setAttribute("content",e?"#000":lightBg),htmlClass[e?"add":"remove"]("dark"),localStorage.setItem("dark",e)},darkScheme=window.matchMedia("(prefers-color-scheme: dark)");if(htmlClass.contains("dark"))setDark(!0);else{const e=localStorage.getItem("dark");setDark(e?e==="true":darkScheme.matches)}darkScheme.addEventListener("change",e=>{setDark(e.matches)});const btnDark=document.querySelector(".btn-dark");btnDark.addEventListener("click",()=>{setDark(localStorage.getItem("dark")!=="true")})</script><div class="nav-wrapper fixed inset-x-0 top-full z-40 flex h-full select-none flex-col justify-center pb-16 duration-200 dark:bg-black lg:static lg:h-auto lg:flex-row lg:!bg-transparent lg:pb-0 lg:transition-none"><nav class="mt-12 flex justify-center space-x-10 dark:invert lg:ml-12 lg:mt-0 lg:items-center lg:space-x-6"><a class="h-8 w-8 text-[0] [background:var(--url)_center_center/cover_no-repeat] lg:h-6 lg:w-6" style=--url:url(./rss.svg) href=https://mindbox.gitee.io/blog/index.xml target=_blank rel=alternate>rss</a></nav></div></header><main class="prose prose-neutral relative mx-auto min-h-[calc(100%-9rem)] max-w-3xl px-8 pb-16 pt-12 dark:prose-invert"><article><header class=mb-16><h1 class="!my-0 pb-2.5">Thinking in Rust No.2 Sized，?Sized</h1><div class="text-sm antialiased opacity-60"><time>Oct 31, 2023</time></div></header><section><p>我想聊的内容基本全部基于Rust的基本库，应该说大部分聊的是core库。
本期聊的内容是Sized，这是一个平时基本用不到，但是最基础的概念。</p><h1 id=rust基本库>Rust基本库</h1><p>Rust的基本库分为三层，core，alloc和std。</p><ol><li>core包含rust最核心的内容，该库除了编译器不依赖任何外部环境，包括堆内存。</li><li>alloc在core基础上添加堆内存的支持，从名字就可以看出来，该库还依赖compiler_builtins，一个公开的库，在crates.io上有，可以查看</li></ol><div class=highlight><pre tabindex=0 style=color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4><code class=language-rust data-lang=rust><span style=display:flex><span><span style=color:#66d9ef>impl</span><span style=color:#f92672>&lt;</span>T<span style=color:#f92672>&gt;</span> Box<span style=color:#f92672>&lt;</span>T<span style=color:#f92672>&gt;</span> {
</span></span><span style=display:flex><span>    <span style=color:#66d9ef>pub</span> <span style=color:#66d9ef>fn</span> <span style=color:#a6e22e>new</span>(x: <span style=color:#a6e22e>T</span>) -&gt; <span style=color:#a6e22e>Self</span> {
</span></span><span style=display:flex><span>        <span style=color:#75715e>#[rustc_box]</span>
</span></span><span style=display:flex><span>        Box::new(x)
</span></span><span style=display:flex><span>    }
</span></span><span style=display:flex><span>}
</span></span></code></pre></div><p>所有的堆分配都会最终到这里，分配堆内存。</p><p>我们熟悉的Box，Vec都是在这个alloc库中。</p><ol start=3><li>std 标准库，依赖alloc，和许多其他的库，比如现在标准库HashMap就是依赖hashbrown库实现的，就是crates.io上那个。</li></ol><p>具体来说是std依赖于alloc，alloc依赖于core，core只依赖编译器。
一般来说写应用是使用std，写嵌入式一般只依赖alloc，如果是写内核，那就只能依赖core了。</p><h1 id=marker>marker</h1><p>在core库中有一个叫marker的mod，里面包含的内容主要有：</p><ul><li>Sized，Copy，Send，Sync，Unpin五个Trait</li><li>PhantomData，PhantomPinned两个Struct</li><li>Derive Copy的宏。</li></ul><p>为什么这些内容在这个mod中呢？这个mod中的内容与编译器的行为息息相关，我们看到的每一个Trait，它们的大小都是零，目的只是给所有的类型添加一个开关。
为什么叫marker，因为对于每一个类型，以上五个Trait编译的时候都能得到是或者否的答案。</p><p>这些内容我们大概可以分为四个部分</p><ol><li>Sized</li><li>Copy，Derive Copy</li><li>Send，Sync，PhantomData</li><li>Unpin，PhantomPinned</li></ol><p>我会逐步的聊这几个部分，本期先聊Sized。</p><h1 id=数据与内存>数据与内存</h1><p>我们使用的所有变量，都是数据，数据要保存在内存中，在保存的时候都需要一个大小，就是占多大的内存，这个大小编译器会自动计算，对于能够计算出大小的类型，都会标注为Sized。
也就是是说编译器自动为所有能够计算大小的类型实现了该Trait。</p><div class=highlight><pre tabindex=0 style=color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4><code class=language-rust data-lang=rust><span style=display:flex><span><span style=color:#66d9ef>struct</span> <span style=color:#a6e22e>A</span>(<span style=color:#66d9ef>u32</span>);
</span></span><span style=display:flex><span><span style=color:#66d9ef>let</span> a1:<span style=color:#a6e22e>A</span>;
</span></span><span style=display:flex><span><span style=color:#66d9ef>let</span> a2:<span style=color:#66d9ef>&amp;</span><span style=color:#a6e22e>A</span>;
</span></span></code></pre></div><p>上面的a1，a2是两种不同的类型，编译器在编译的时候能够计算到它们的长度，所以每一个都自动实现了Sized。
也就是说编译器自动为我们做了下面的事情。</p><div class=highlight><pre tabindex=0 style=color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4><code class=language-rust data-lang=rust><span style=display:flex><span><span style=color:#66d9ef>impl</span> Sized <span style=color:#66d9ef>for</span> A;
</span></span><span style=display:flex><span><span style=color:#66d9ef>impl</span> Sized <span style=color:#66d9ef>for</span> <span style=color:#f92672>&amp;</span>A;
</span></span></code></pre></div><p>是的，A，&amp;A完完全全是两个东西，但是为啥我们在a1或者a2 上都可以通过 . 来调用它们的函数呢？这个涉及到Deref，刨坑待填。</p><p>所以Sized 是一个开关，编译器自动帮所有类型确定，那么既然是开关，开就是有固定长度，关就是没有固定长度，那么什么是没有固定长度呢？</p><h1 id=dstdynamically-sized-types>DST（dynamically sized types）</h1><p>在Rust中，在编译的时候不能确定长度的类型，有一个专有名词叫DST。</p><p>我们日常的开发一直在与DST打交道，Rust中DST主要是下面这三种：</p><ol><li>str</li><li>[T]</li><li>dyn Trait</li></ol><p>编译的时候这三种类型的大小是无法确定的，所以它们的Sized是关闭的，没有实现,所以很多代码我们是编译不过的，例如下面这种：</p><div class=highlight><pre tabindex=0 style=color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4><code class=language-rust data-lang=rust><span style=display:flex><span><span style=color:#66d9ef>let</span> a1: <span style=color:#66d9ef>str</span> <span style=color:#f92672>=</span> <span style=color:#e6db74>&#34;test&#34;</span>;
</span></span><span style=display:flex><span><span style=color:#66d9ef>let</span> a2: [<span style=color:#66d9ef>u32</span>] <span style=color:#f92672>=</span> [<span style=color:#ae81ff>0</span><span style=color:#66d9ef>u32</span>;<span style=color:#ae81ff>1</span>];
</span></span><span style=display:flex><span><span style=color:#66d9ef>let</span> a3: <span style=color:#a6e22e>dyn</span> AsRef<span style=color:#f92672>&lt;</span><span style=color:#66d9ef>str</span><span style=color:#f92672>&gt;</span> <span style=color:#f92672>=</span> String::from(<span style=color:#e6db74>&#34;test&#34;</span>);
</span></span></code></pre></div><p>那么DST怎么用呢？我们只能定义具有Sized Trait的变量，SDT没有，但是对DST的引用有，所以像下面这样就可以编译。</p><div class=highlight><pre tabindex=0 style=color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4><code class=language-rust data-lang=rust><span style=display:flex><span><span style=color:#66d9ef>let</span> a1: <span style=color:#66d9ef>&amp;</span><span style=color:#66d9ef>str</span> <span style=color:#f92672>=</span> <span style=color:#e6db74>&#34;test&#34;</span>;
</span></span><span style=display:flex><span><span style=color:#66d9ef>let</span> a2: <span style=color:#66d9ef>&amp;</span>[<span style=color:#66d9ef>u32</span>] <span style=color:#f92672>=</span> <span style=color:#f92672>&amp;</span>[<span style=color:#ae81ff>0</span><span style=color:#66d9ef>u32</span>; <span style=color:#ae81ff>1</span>];
</span></span><span style=display:flex><span><span style=color:#66d9ef>let</span> a3: <span style=color:#66d9ef>&amp;</span><span style=color:#a6e22e>dyn</span> AsRef<span style=color:#f92672>&lt;</span><span style=color:#66d9ef>str</span><span style=color:#f92672>&gt;</span> <span style=color:#f92672>=</span> <span style=color:#f92672>&amp;</span>String::from(<span style=color:#e6db74>&#34;test&#34;</span>);
</span></span></code></pre></div><p>动态类型没有大小无法实例化，动态类型的引用有大小，所以可以实例化。
那么编译器是怎么识别以上的错误的呢？</p><p>编译器的做法很简单，就是给所有需要类型的地方都加上Sized的需要，比如：</p><div class=highlight><pre tabindex=0 style=color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4><code class=language-rust data-lang=rust><span style=display:flex><span><span style=color:#66d9ef>struct</span> <span style=color:#a6e22e>A</span><span style=color:#f92672>&lt;</span>T<span style=color:#f92672>&gt;</span> {
</span></span><span style=display:flex><span>	t: <span style=color:#a6e22e>T</span>,
</span></span><span style=display:flex><span>}
</span></span><span style=display:flex><span><span style=color:#75715e>// 编译器眼里是这样的
</span></span></span><span style=display:flex><span><span style=color:#75715e></span><span style=color:#66d9ef>struct</span> <span style=color:#a6e22e>A</span><span style=color:#f92672>&lt;</span>T:Sized<span style=color:#f92672>&gt;</span>{
</span></span><span style=display:flex><span>	t:<span style=color:#a6e22e>T</span>,
</span></span><span style=display:flex><span>}
</span></span><span style=display:flex><span><span style=color:#75715e>// 所以
</span></span></span><span style=display:flex><span><span style=color:#75715e></span><span style=color:#66d9ef>let</span> a:<span style=color:#a6e22e>A</span><span style=color:#f92672>&lt;</span><span style=color:#66d9ef>u32</span><span style=color:#f92672>&gt;</span>; <span style=color:#75715e>// 可以
</span></span></span><span style=display:flex><span><span style=color:#75715e></span><span style=color:#66d9ef>let</span> b:<span style=color:#66d9ef>&amp;</span><span style=color:#a6e22e>A</span><span style=color:#f92672>&lt;</span><span style=color:#66d9ef>u32</span><span style=color:#f92672>&gt;</span>;<span style=color:#75715e>// 可以
</span></span></span><span style=display:flex><span><span style=color:#75715e></span><span style=color:#66d9ef>let</span> c:<span style=color:#a6e22e>A</span><span style=color:#f92672>&lt;</span><span style=color:#66d9ef>str</span><span style=color:#f92672>&gt;</span>; <span style=color:#75715e>// 不可以
</span></span></span><span style=display:flex><span><span style=color:#75715e></span><span style=color:#66d9ef>let</span> d:<span style=color:#66d9ef>&amp;</span><span style=color:#a6e22e>A</span><span style=color:#f92672>&lt;</span><span style=color:#66d9ef>str</span><span style=color:#f92672>&gt;</span>;<span style=color:#75715e>// 不可以
</span></span></span></code></pre></div><p>那么既然Sized是一个开关，能不能手动关闭呢？</p><p>答案是不能。Sized是编译器计算出来的，我们不能让一个有固定长度的类型让它没有长度，反之亦然。</p><p>但是有一种情况，是可以调整的，就是上面情况中的 d 变量。</p><h1 id=sized>?Sized</h1><p>范型的参数我们可以理解为是一种类型过滤器，就是A结构体可以接受除了DST以外的所有类型，那么我们可不可以把这个除DST以外这个条件也去掉呢？
就是所有的类型 A 结构体都可以接受。
答案是可以的。</p><div class=highlight><pre tabindex=0 style=color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4><code class=language-rust data-lang=rust><span style=display:flex><span>	<span style=color:#66d9ef>struct</span> <span style=color:#a6e22e>A</span><span style=color:#f92672>&lt;</span>T:<span style=color:#f92672>?</span>Sized<span style=color:#f92672>&gt;</span> {
</span></span><span style=display:flex><span>		t: <span style=color:#a6e22e>T</span>,
</span></span><span style=display:flex><span>	}
</span></span><span style=display:flex><span>	<span style=color:#66d9ef>let</span> a:<span style=color:#a6e22e>A</span><span style=color:#f92672>&lt;</span><span style=color:#66d9ef>u32</span><span style=color:#f92672>&gt;</span>;
</span></span><span style=display:flex><span>	<span style=color:#66d9ef>let</span> b:<span style=color:#66d9ef>&amp;</span><span style=color:#a6e22e>A</span><span style=color:#f92672>&lt;</span><span style=color:#66d9ef>u32</span><span style=color:#f92672>&gt;</span>;
</span></span><span style=display:flex><span>	<span style=color:#75715e>// let c:A&lt;str&gt;;	// 依旧不可以
</span></span></span><span style=display:flex><span><span style=color:#75715e></span>	<span style=color:#66d9ef>let</span> d:<span style=color:#66d9ef>&amp;</span><span style=color:#a6e22e>A</span><span style=color:#f92672>&lt;</span><span style=color:#66d9ef>str</span><span style=color:#f92672>&gt;</span>;	<span style=color:#75715e>// 现在可以了
</span></span></span></code></pre></div><p>这种情况我们日常用的不多，但是标准库的有些类型是这样设计的，比如Borrow，Cell，</p><div class=highlight><pre tabindex=0 style=color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4><code class=language-rust data-lang=rust><span style=display:flex><span><span style=color:#66d9ef>pub</span> <span style=color:#66d9ef>struct</span> <span style=color:#a6e22e>Cell</span><span style=color:#f92672>&lt;</span>T: <span style=color:#f92672>?</span>Sized<span style=color:#f92672>&gt;</span> {
</span></span><span style=display:flex><span>    value: <span style=color:#a6e22e>UnsafeCell</span><span style=color:#f92672>&lt;</span>T<span style=color:#f92672>&gt;</span>,
</span></span><span style=display:flex><span>}
</span></span><span style=display:flex><span>
</span></span><span style=display:flex><span><span style=color:#66d9ef>let</span> a:<span style=color:#66d9ef>&amp;</span><span style=color:#a6e22e>Cell</span><span style=color:#f92672>&lt;</span><span style=color:#66d9ef>str</span><span style=color:#f92672>&gt;</span>; <span style=color:#75715e>// 是的，你可以这样写。
</span></span></span></code></pre></div><p>一些包含借用的结构体，都是包含这个?Sized，比如后面讲的Pin，实现中是必须有这个标志才能实现。</p><h1 id=sized在trait定义中的另外一种用法>Sized在Trait定义中的另外一种用法</h1><p>比如我们要建立一个界面库，可能需要这么写：</p><div class=highlight><pre tabindex=0 style=color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4><code class=language-rust data-lang=rust><span style=display:flex><span><span style=color:#66d9ef>trait</span> View {
</span></span><span style=display:flex><span>	<span style=color:#66d9ef>fn</span> <span style=color:#a6e22e>clone</span>(<span style=color:#f92672>&amp;</span>self)-&gt;<span style=color:#a6e22e>Self</span>;
</span></span><span style=display:flex><span>	<span style=color:#66d9ef>fn</span> <span style=color:#a6e22e>show</span>(<span style=color:#f92672>&amp;</span>self);
</span></span><span style=display:flex><span>}
</span></span><span style=display:flex><span><span style=color:#66d9ef>let</span> v:<span style=color:#66d9ef>&amp;</span><span style=color:#a6e22e>dyn</span> View; <span style=color:#75715e>// 不可以
</span></span></span></code></pre></div><p>这里不可以的原因出在这个clone函数上，当建立dyn View这个DST的时候，需要建立类似C++的虚表，而虚表中无法添加这个clone函数。
因为我们无法在编译的时候知道clone的返回值的大小。</p><p>这个代码要编译通过需要这么写：</p><div class=highlight><pre tabindex=0 style=color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4><code class=language-rust data-lang=rust><span style=display:flex><span><span style=color:#66d9ef>trait</span> View {
</span></span><span style=display:flex><span>	<span style=color:#66d9ef>fn</span> <span style=color:#a6e22e>clone</span>(<span style=color:#f92672>&amp;</span>self)-&gt;<span style=color:#a6e22e>Self</span> <span style=color:#66d9ef>where</span> Self:Sized;
</span></span><span style=display:flex><span>	<span style=color:#66d9ef>fn</span> <span style=color:#a6e22e>show</span>(<span style=color:#f92672>&amp;</span>self);
</span></span><span style=display:flex><span>}
</span></span><span style=display:flex><span><span style=color:#66d9ef>let</span> v:<span style=color:#66d9ef>&amp;</span><span style=color:#a6e22e>dyn</span> View;
</span></span></code></pre></div><p>建立虚表的时候要求&amp;self是DST，这里的逻辑是手动给Self加一个Sized的过滤器，把这个函数从虚表中过滤掉。
这样做的结果可以编译过了，虚表中只有show这个函数，没有clone函数了，这样就能编译过了。
当然附带的结果是v.clone()无法调用了。</p><h1 id=总结>总结</h1><p>Sized就是一个开关，Rust编译器会自动帮我们在类型上打开或者关闭这个开关，在特殊的情况下，我们可以通过代码手动的打开或者关闭这个开关的过滤器来实现具体的目的。</p><p>Rust中有许多的逻辑都是通过空的Trait这样的开关来过滤和检查某些合法性，这样在编译器就可以检查出程序不合理的地方。</p><p>最后补上Sized的定义：</p><div class=highlight><pre tabindex=0 style=color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4><code class=language-rust data-lang=rust><span style=display:flex><span><span style=color:#66d9ef>pub</span> <span style=color:#66d9ef>trait</span> Sized {
</span></span><span style=display:flex><span>    <span style=color:#75715e>// Empty.
</span></span></span><span style=display:flex><span><span style=color:#75715e></span>}
</span></span></code></pre></div><p>是的，空空如也，什么都没有，在编译的时候它存在，在运行的时候它不存在，对程序的性能的影响是零，也是Rust实现零成本抽样固定套路。</p><p>下一期讨论Copy，一个与Sized套路一样，但是逻辑完全相反的故事。</p></section></article></main><footer class="opaco mx-auto flex h-[4.5rem] max-w-3xl items-center px-8 text-[0.9em] opacity-60"><div class=mr-auto>&copy; 2024
<a class=link href=https://mindbox.gitee.io/blog>mindbox's blog</a></div><a class="link mx-6" href=https://gohugo.io/ rel=noopener target=_blank>Powered by Hugo️️</a>️
<a class=link href=https://github.com/nanxiaobei/hugo-paper rel=noopener target=_blank>✎ Paper</a></footer></body></html>